package main

import "fmt"

type A interface {
	comparable
	Print()
}

type B[T A] struct {
	t T
}

type C int

func (c C) Print() {
	fmt.Println("C Print")
}

func main() {

	b := B[C]{C(1)}
	b.t.Print()

	m := max(1, 4, 5, 7)
	println(m)
}

// //基础数据类型比较 (大小比较)
// a := 1
// b := 2
// if a > b {
// 	println("a > b")
// } else {
// 	println("a <= b")
// }

////指针比较(只能==, !=比较，纯粹的地址比较)
// a := 1
// b := 2
// ptr_a := &a
// ptr_b := &b
// if ptr_a == ptr_b {
// 	println("ptr_a > ptr_b")
// } else {
// 	println("ptr_a <= ptr_b")
// }

// //数组类型比较 (只有当长度相同并且元素类型是可比较类型才能比较，而且所有元素都相等时才相等,这里是两个条件哈)
// // 切片, map, 函数类型是非比较类型
// a1 := [3]int{1, 2, 3}
// b1 := [3]int{1, 2, 3}
// if a1 == b1 {
// 	println("a1 == b1")
// } else {
// 	println("a1 != b1")
// }
// a2 := [4]map[string]int{{"a": 1}, {"b": 2}, {"c": 3}, {"d": 4}}
// b2 := [4]map[string]int{{"a": 1}, {"b": 2}, {"c": 3}, {"d": 4}}
// if a2 == b2 {
// }
// a3 := [4][]int{{1, 2, 3}, {4, 5, 6}, {7, 8, 9}, {10, 11, 12}}
// b3 := [4][]int{{1, 2, 3}, {4, 5, 6}, {7, 8, 9}, {10, 11, 12}}
// if a3 == b3 {
// }
// a4 := [4]func(){}
// b4 := [4]func(){}
// if a4 == b4 {
// }

// type A struct {
// 	a int
// 	b int
// }

// a3 := [1]A{{1, 2}}
// b3 := [1]A{{1, 2}}
// if a3 == b3 {
// }

// type B struct {
// 	a int
// 	b int
// 	c []int
// }
// a4 := [1]B{{1, 2, []int{1, 2, 3}}}
// b4 := [1]B{{1, 2, []int{1, 2, 3}}}
// if a4 == b4 {
// }

// type C struct {
// 	a int
// 	b int
// 	c map[string]int
// }

// a5 := [1]C{{1, 2, map[string]int{"a": 1, "b": 2, "c": 3}}}
// b5 := [1]C{{1, 2, map[string]int{"a": 1, "b": 2, "c": 3}}}
// if a5 == b5 {
// }

// type D struct {
// 	a int
// 	b int
// 	c func()
// }

// a6 := [1]D{{1, 2, func() {}}}
// b6 := [1]D{{1, 2, func() {}}}
// if a6 == b6 {
// }

// 结构体比较 (结构体比较必须要所有字段都是可比较的才能比较，结构体要相等需要对应字段的值相等)
// 切片, map, 函数类型是非比较类型
// type S struct {
// 	a int
// 	b int
// }

// s_a1 := S{1, 2}
// s_b1 := S{1, 2}
// if s_a1 == s_b1 {
// }
// type S1 struct {
// 	a int
// 	b int
// }
// s_a2 := S1{1, 2}
// //类型不同不能比较
// if s_a2 == s_b1 {
// }

// type S struct {
// 	a int
// 	b []int
// }
// s_a3 := S{1, []int{1, 2, 3}}
// s_b3 := S{1, []int{1, 2, 3}}
// if s_a3 == s_b3 {
// }

// //泛型应用
// type P[T comparable] struct {
// 	a T
// }

// p_a1 := P[int]{1}
// p_b1 := P[int]{1}
// if p_a1 == p_b1 {
// }

// p_a2 := P[int]{1}
// p_b2 := P[string]{"1"}
// if p_a2 == p_b2 {
// }

// type S struct {
// 	comparable
// }
// }
